﻿using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SteroMood
{
    /// <summary>
    /// A class that manages a global low level keyboard hook
    /// </summary>
    public class GlobalKeyboardHook
    {
        #region Constant, Structure and Delegate Definitions
        /// <summary>
        /// defines the callback type for the hook
        /// </summary>
        public delegate int KeyboardHookProcDelegate(int code, int wParam, IntPtr lParam);

        public struct KeyboardHookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }

        const int WH_KEYBOARD_LL = 13;
        const int WM_KEYDOWN = 0x100;
        const int WM_KEYUP = 0x101;
        const int WM_SYSKEYDOWN = 0x104;
        const int WM_SYSKEYUP = 0x105;

        const int VK_SHIFT = 0x10;
        const int VK_CAPITAL = 0x14;
        const int VK_NUMLOCK = 0x90;
        const int VK_CONTROL = 0x11;
        const int VK_ALT = 0x12;

        const int VK_MEDIA_NEXT_TRACK = 0xB0;
        const int VK_MEDIA_PREV_TRACK = 0xB1;
        const int VK_MEDIA_STOP = 0xB2;
        const int VK_MEDIA_PLAY_PAUSE = 0xB3;

        private KeyboardHookProcDelegate _keyboardHookDelegateRef;
        #endregion

        #region Instance Variables
        public int KeyModifier { get; set; }
        /// <summary>
        /// Handle to the hook, need this to unhook and call the next hook
        /// </summary>
        IntPtr _hhook = IntPtr.Zero;
        #endregion

        #region Events

        /// <summary>
        /// Occurs when one of the hooked keys is pressed
        /// </summary>
        public event KeyEventHandler KeyDown;
        /// <summary>
        /// Occurs when one of the hooked keys is released
        /// </summary>
        public event KeyEventHandler KeyUp;
        #endregion

        #region Constructors and Destructors
        /// <summary>
        /// Initializes a new instance of the <see cref="GlobalKeyboardHook"/> class and installs the keyboard hook.
        /// </summary>
        public GlobalKeyboardHook()
        {
            Hook();
        }

        /// <summary>
        /// Releases unmanaged resources and performs other cleanup operations before the
        /// <see cref="GlobalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
        /// </summary>
        ~GlobalKeyboardHook()
        {
            Unhook();
        }

        /// <summary>
        /// Installs the global hook
        /// </summary>
        private void Hook()
        {
            IntPtr hInstance = LoadLibrary("User32");
            _keyboardHookDelegateRef = new KeyboardHookProcDelegate(KeyboardHookProc);
            _hhook = SetWindowsHookEx(WH_KEYBOARD_LL, _keyboardHookDelegateRef, hInstance, 0);
        }

        /// <summary>
        /// Uninstalls the global hook
        /// </summary>
        private void Unhook()
        {
            UnhookWindowsHookEx(_hhook);
        }

        #endregion

        #region Public Methods

        public static Keys ApplyModifierKeys(Keys key)
        {
            Keys modifierKeys = key;
            if (GetKeyState(VK_SHIFT) < 0)
            {
                modifierKeys |= Keys.Shift;
            } //~ if
            if (GetKeyState(VK_CONTROL) < 0)
            {
                modifierKeys |= Keys.Control;
            } //~ if
            if (GetKeyState(VK_ALT) < 0)
            {
                modifierKeys |= Keys.Alt;
            } //~ if
            return modifierKeys;
        }

        /// <summary>
        /// The callback for the keyboard hook
        /// </summary>
        /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
        /// <param name="wParam">The event type</param>
        /// <param name="lParam">The keyhook event information</param>
        /// <returns></returns>
        private int KeyboardHookProc(int code, int wParam, IntPtr lParam)
        {
            if (code >= 0)
            {
                KeyboardHookStruct myKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
                Keys key = (Keys)myKeyboardHookStruct.vkCode;
                KeyEventArgs keyArg = new KeyEventArgs(ApplyModifierKeys(key));
                if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
                {
                    if (KeyDown != null)
                    {
                        KeyDown(this, keyArg);
                    }
                }
                else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
                {
                    if (KeyUp != null)
                    {
                        KeyUp(this, keyArg);
                    }
                }

                if (keyArg.Handled)
                {
                    return -1;
                }
            }
            return CallNextHookEx(_hhook, code, wParam, lParam);
        }
        #endregion

        #region DLL imports
        /// <summary>
        /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
        /// </summary>
        /// <param name="idHook">The id of the event you want to hook</param>
        /// <param name="callback">The callback.</param>
        /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
        /// <param name="threadId">The thread you want to attach the event to, can be null</param>
        /// <returns>a handle to the desired hook</returns>
        [DllImport("user32.dll")]
        static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProcDelegate callback, IntPtr hInstance, uint threadId);

        /// <summary>
        /// Unhooks the windows hook.
        /// </summary>
        /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
        /// <returns>True if successful, false otherwise</returns>
        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hInstance);

        /// <summary>
        /// The GetKeyState function retrieves the status of the specified virtual key. The status specifies whether the key is up, down, or toggled 
        /// (on, off—alternating each time the key is pressed). 
        /// </summary>
        /// <param name="vKey">
        /// [in] Specifies a virtual key. If the desired virtual key is a letter or digit (A through Z, a through z, or 0 through 9), nVirtKey must be set to the ASCII value of that character. For other keys, it must be a virtual-key code. 
        /// </param>
        /// <returns>
        /// The return value specifies the status of the specified virtual key, as follows: 
        ///If the high-order bit is 1, the key is down; otherwise, it is up.
        ///If the low-order bit is 1, the key is toggled. A key, such as the CAPS LOCK key, is toggled if it is turned on. The key is off and untoggled if the low-order bit is 0. A toggle key's indicator light (if any) on the keyboard will be on when the key is toggled, and off when the key is untoggled.
        /// </returns>
        /// <remarks>http://msdn.microsoft.com/en-us/library/ms646301.aspx</remarks>
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern short GetKeyState(int vKey);

        /// <summary>
        /// Calls the next hook.
        /// </summary>
        /// <param name="idHook">The hook id</param>
        /// <param name="nCode">The hook code</param>
        /// <param name="wParam">The wparam.</param>
        /// <param name="lParam">The lparam.</param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, IntPtr lParam);

        /// <summary>
        /// Loads the library.
        /// </summary>
        /// <param name="lpFileName">Name of the library</param>
        /// <returns>A handle to the library</returns>
        [DllImport("kernel32.dll")]
        static extern IntPtr LoadLibrary(string lpFileName);
        #endregion
    }
}